package kr.co.bettersoft.sendme.activity;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import org.apache.commons.io.IOUtils;
import org.json.JSONArray;
import org.json.JSONObject;

import kr.co.bettersoft.sendme.provider.SendMeLog;
import kr.co.bettersoft.sendme.provider.SendMeVoice;
import kr.co.bettersoft.sendme.rest.SendMeAudioMessageRest;
import kr.co.bettersoft.sendme.rest.SendMeLogRest;
import kr.co.bettersoft.sendme.util.SendMeActivityManager;
import kr.co.bettersoft.sendme.util.SendMeCommon;
import kr.co.bettersoft.sendme.util.SendMeConstant;
import kr.co.bettersoft.sendme.util.SendMeCustomTimePickerDialog;
import kr.co.bettersoft.sendme.util.SendMeDBManagerAudioRecord;
import kr.co.bettersoft.sendme.activity.R;

import com.uraroji.garage.android.mp3recvoice.RecMicToMp3;

import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.app.DatePickerDialog.OnDateSetListener;
import android.app.ProgressDialog;
import android.app.TimePickerDialog;
import android.app.TimePickerDialog.OnTimeSetListener;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.TimePicker;
import android.widget.Toast;

/**
 * mp3 방식으로 녹음 
 *   - 특정 디렉토리 지정하여 녹음 
 *   - 일시정지 기능 구현.  
 * @author blue
 *
 */
public class SendMeAudioRecordActivity extends Activity implements OnClickListener, OnCompletionListener{

	public static String TAG = SendMeAudioRecordActivity.class.getSimpleName();
	
	// 액티비티 매니저를 가져 온다.
	private SendMeActivityManager sendMeActivityManager = SendMeActivityManager.getInstance();

	String applicationAudioTempDirectory = SendMeConstant.APPLICATION_AUDIO_TEMP_DIRECTORY; 		//"/Android/data/kr.pe.jonhkim.sendme.activity/.AudioRecord/temp";			// 녹음 중인 임시파일 저장될 경로 지정, 탐색기,미디어 스캐너에 나타나지 않게 비공개 처리 

	SimpleDateFormat reservationDateSimpleDateFormat = SendMeConstant.reservationDateSimpleDateFormat;	// 날짜 선택 포맷(출력용)
	SimpleDateFormat reservationTimeSimpleDateFormat = SendMeConstant.reservationTimeSimpleDateFormat;	// 시간 선택 포맷(출력용)
	SimpleDateFormat reservationDateSimpleDateFormatForSend = SendMeConstant.reservationDateSimpleDateFormatForSend;	// 시간 선택 포맷(전송용)
	SimpleDateFormat reservationTimeSimpleDateFormatForSend = SendMeConstant.reservationTimeSimpleDateFormatForSend;	// 시간 선택 포맷(전송용)

	private RecMicToMp3 mRecMicToMp3;				// 에뮬레이터에서 마이크 입력 샘플링 속도는 8KHz 밖에 지원하지 않는 모양 // エミュレータではマイクからの入力サンプリングレートは8KHzしかサポートしていない模様

	// 녹음 음성 재생기
	private MediaPlayer mPlayer = null;

	// 데이터 전달용 번들과 인텐트
	Bundle extraBundle;
	Intent resultIntent;
	
	// 파일명
	String fileName;

	// 보내는 사람 전번
	String sender;
	// 받는 사람 전번
	String[] receiverList ;
	String[] receiverNameList ;
	
	// 받는 사람 표시 뷰
	TextView audioRecordReceiverNameTxt;

	// 녹음 가능 시간
	int usableSecond = SendMeConstant.RECORDING_TIME / 1000;		// 녹음 가능한 시간값(초)
	TextView usableSecondTxt;										// 녹음 가능한 시간 표시창
	TextView recordedTimeTxt;										// 녹음 된 시간 표시 뷰

	// 마이크 이미지 (on/off 변경용도)
	ImageView recordingViewImage;

	// 녹음 진행 상태 바
	SeekBar recordSeekBar;
	private int mProgressCheckStepMs = SendMeConstant.mProgressCheckStepMs;		// 녹음 및 재생에서 진행바의 갱신 간격(ms 단위) : 0.5초마다 체크
	private int mCurRecTimeMs = 0;				// 현재까지 녹음한 시간값
	private int mCurProgressTimeDisplay = 0;	// 녹음한 시간 보여주기 값 

	// 재생 중 표시
	SeekBar playSeekbar;		// 재생 진행 상태 바
	TextView mTvPlayMaxPoint;	// 전체 재생 시간

	// 하단 녹음 관련 버튼들
	ImageButton startButton;
	ImageButton stopButton;
	ImageButton pauseButton;
	ImageButton resumeButton;

	// 하단 녹음 이후 메뉴 버튼들
	ImageButton recordingMenuSaveBtn;
	ImageButton recordingMenuSendBtn;
	ImageButton recordingMenuReservationBtn;
	ImageButton recordingMenuPlayBtn;
	ImageButton recordingMenuDeleteBtn;

	// 하단 녹음 관련 각 버튼들의 레이아웃 (보이기/숨기기 용도)
	View recordingStartBtnLayout;
	View recordingResumeBtnLayout;
	View recordingPauseBtnLayout;
	View recordingStopBtnLayout;

	// 녹음 화면에서 녹음 상태 표시 레이아웃
	View recordWaitStatusLayout;
	View recordRecordingStatusLayout;		
	View recordRecordeResultLayout;

	// 상단 녹음 관련 스크린 레이아웃
	View audioRecordScreenLayout;
	// 상단 재생 관련 스크린 레이아웃
	View audioPlayScreenLayout;
	// 하단 녹음 관련 버튼 레이아웃
	View bottomRecordButtonsLayout;
	// 하단 녹음 이후 메뉴 레이아웃
	View bottomRecordMenuLayout;


	ImageButton imageButtonTopBack;
	ImageButton imageButtonTopMainMenu;
	
	// 프로그래스바(로딩 표시)
	private ProgressDialog dialog;

	
	// 로그를 남긴다
	private static final int THREAD_REGISTER_LOG = 100;
	
	// 녹음을 시작한다
	private static final int THREAD_RECORDING_START = 101;			

	// 녹음을 완료한다
	private static final int THREAD_RECORDING_STOP = 102;

	// 녹음을 중지한다
	private static final int THREAD_RECORDING_PAUSE = 103;

	// 녹음을 재개한다
	private static final int THREAD_RECORDING_RESUME = 104;
	
	// 녹음을 재생한다
	private static final int THREAD_PLAYING_RECORD = 105;
	
	
	
	// 음성 메시지 전송전 확인 창을 띄운다				
	private static final int THREAD_CONFIRM_SEND_AUDIO = 106;		

//	// 음성 메시지 예약 전송전 확인 창을 띄운다
//	private static final int THREAD_CONFIRM_RESERVATION_SEND_AUDIO = 107;
//	
//	// 음성 메시지 예약 화면에서 예약 날짜, 시간을 선택하라는 알림을 띄운다			
//	private static final int THREAD_RESERVATION_SEND_TIME_NOT_SELECTED = 115;	

	
	// 프로그레스 바를 출력 한다.
	private static final int THREAD_PROGRESS_BAR_VISIBLE = 108;

	// 프로그레스 바를 감춘다.
	private static final int THREAD_PROGRESS_BAR_INVISIBLE = 109;

	// 등록 성공 토스트를 띄운다
	private static final int THREAD_TOAST_SEND_SUCCESS = 110;

//	// 예약 등록 성공 토스트를 띄운다
//	private static final int THREAD_TOAST_RESERVATION_SEND_SUCCESS = 111;
	
	// 등록 실패 토스트를 띄운다
	private static final int THREAD_TOAST_SEND_FAIL = 112;		

	
	// 예약 전송 화면으로 전환한다
	private static final int THREAD_CHANGE_TO_RESERVATION_SCREEN = 113;		

	// 예약 화면에서 메뉴를 콜함. 이 액티비티도 종료해야함
	private static final int RESULT_MAIN_MENU_CALLED = 600;		
	
	// 음성 메시지를 임시 저장할지 확인받는다
	private static final int CONFIRM_SAVE_TEMP_AUDIO_FILE = 119;		
	
	// 음성 메시지를 임시 저장한다
	private static final int THREAD_SAVE_TEMP_AUDIO_FILE = 114;		
	
	// 임시 저장 성공 토스트를 띄운다
	private static final int THREAD_TOAST_TEMP_SAVE_SUCCESS = 116;	
	
	// 임시 저장 실패 토스트를 띄운다
	private static final int THREAD_TOAST_TEMP_SAVE_FAIL = 118;		
	
	// 녹음 화면 호출
	private static final int RECORDING_SCREEN_CALL = 135;
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
	/*
	 * 녹음기 초기화
	 */
	public void initRecMicToMp3(){
		fileName = System.currentTimeMillis() +".mp3";	
		String tempFileName = tempMP3FileName();
		mRecMicToMp3 = new RecMicToMp3(tempFileName, 8000);				// 8000 또는 44100
	}

	/*
	 * temp 파일명 구하기 - 현시각 ms 단위로. 
	 */
	public String tempMP3FileName(){
		// 디렉토리 없으면 생성
		File file = new File(Environment.getExternalStorageDirectory().getPath(), applicationAudioTempDirectory);
		
		if(!file.exists()){
			file.mkdirs();
		}
		
		return Environment.getExternalStorageDirectory() + applicationAudioTempDirectory + "/" + fileName;		
	}

	// 녹음시 SeekBar 처리
	Handler mProgressHandler = new Handler()
	{
		public void handleMessage(Message msg)
		{
			// 특정 조건 (현재 녹음중) 에만 동작하도록 함
			if(mRecMicToMp3.isRecording()) {		
				if(mRecMicToMp3.isPuased()) {
					mProgressHandler.sendEmptyMessageDelayed(0, mProgressCheckStepMs);	// 녹음이 완료될때까지 체크는 계속 하고 있어야 함
				} else {
					mCurRecTimeMs = mCurRecTimeMs + mProgressCheckStepMs;
					mCurProgressTimeDisplay = mCurProgressTimeDisplay + mProgressCheckStepMs;
					// 녹음시간이 음수이면 정지버튼을 눌러 정지시켰음을 의미하므로 
					// SeekBar는 그대로 정지시키고 레코더를 정지시킨다. 
					if (mCurRecTimeMs < 0)
					{}
					// 녹음시간이 아직 최대녹음제한시간보다 작으면 녹음중이라는 의미이므로
					// SeekBar의 위치를 옮겨주고 0.1초 후에 다시 체크하도록 한다. 
					else if (mCurRecTimeMs < (SendMeConstant.RECORDING_TIME))	// 2000 -> usableSecond -> SendMeConstant.RECORDING_TIME
					{
						recordSeekBar.setProgress(mCurProgressTimeDisplay);
						mProgressHandler.sendEmptyMessageDelayed(0, mProgressCheckStepMs);
						recordedTimeTxt.setText((mCurRecTimeMs/1000)+"");
					}
					// 녹음시간이 최대 녹음제한 시간보다 크면 녹음을 정지 시킨다. 
					else
					{
						mHandler.sendMessage(mHandler.obtainMessage(THREAD_RECORDING_STOP));
					}
				}
			}
		}
	};
	// 재생시 SeekBar 처리
	Handler mProgressHandler2 = new Handler()
	{
		public void handleMessage(Message msg)
		{
			if (mPlayer == null) return;
			try
			{
				if (mPlayer.isPlaying())
				{
					//					Log.d(TAG,"mPlayer.getCurrentPosition():"+mPlayer.getCurrentPosition());
					if(mPlayer.getCurrentPosition()>0){		// 재생 끝나고나서도 동작되어 0이 표시되는 경우가 있기 때문에 0은 표시해주지 않도록 처리
						playSeekbar.setProgress(mPlayer.getCurrentPosition());
					}
					mProgressHandler2.sendEmptyMessageDelayed(0, mProgressCheckStepMs);
				}
			}
			catch (IllegalStateException e)
			{}
			catch (Exception e)
			{}
		}
	};

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		// 커스텀 타이블 바를 설정 한다.
		Window window = getWindow();
		window.requestFeature(Window.FEATURE_CUSTOM_TITLE);

		setContentView(R.layout.activity_send_me_audio_record);

		window.setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title_bar_03);

		// 액티비티 매니저에 담는다.
		sendMeActivityManager.addActivity(this);

		// 내 전화번호 (보낸 사람 전화번호) 획득
		confirmNotification();

		
		
		extraBundle = new Bundle();
		resultIntent = new Intent();
		
		
		// 뒤로 가기 화살표 버튼을 설정 한다.
		imageButtonTopBack = (ImageButton)findViewById(R.id.imageButtonTopBack);
		imageButtonTopBack.setOnClickListener(new View.OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub

//				// 화면을 닫는다.
//				deleteTempFileAndFinishActivity();
				
				// 화면을 닫는다.
				// 취소 역할. 자신만 종료
				extraBundle.putBoolean("finishYn", false);	
				resultIntent.putExtras(extraBundle);
				setResult(RESULT_CANCELED, resultIntent);
				deleteTempFileAndFinishActivity();
				
			}
		});

		// 타이틀바의 메인 메뉴 버튼을 설정 한다.
		imageButtonTopMainMenu = (ImageButton)findViewById(R.id.imageButtonTopMainMenu);
		imageButtonTopMainMenu.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				Log.i(TAG, "pressed top main menu.");

				// 메인 메뉴 화면을 출력 한다.
				Intent i = new Intent(SendMeAudioRecordActivity.this, SendMeMainMenuActivity.class);
				startActivity(i);
				
				// 화면을 닫는다. 메뉴 콜. 부모도 종료
				setResult(RESULT_MAIN_MENU_CALLED, resultIntent);
				deleteTempFileAndFinishActivity();
			}
		});
		
		
		// 전달받은 받는 사람(리스트) 를 획득
		Intent getIntent = getIntent();
		receiverList = getIntent.getStringArrayExtra("receiverList");
		receiverNameList = getIntent.getStringArrayExtra("receiverNameList");		
		
		// 녹음 된 시간
		recordedTimeTxt = (TextView) findViewById(R.id.audio_record_recorded_second_txt);

		// 녹음 상태 표시 레이아웃들
		recordWaitStatusLayout  = (View) findViewById(R.id.record_wait_status_layout);			// 녹음 전
		recordRecordingStatusLayout  = (View) findViewById(R.id.record_recording_status_layout);	// 녹음 중
		recordRecordeResultLayout  = (View) findViewById(R.id.record_recorde_result_layout);		// 녹음 후

		// 녹음 관련 버튼들의 레이아웃
		recordingStartBtnLayout = (View) findViewById(R.id.recording_start_btn_layout);
		recordingResumeBtnLayout = (View) findViewById(R.id.recording_resume_btn_layout);
		recordingPauseBtnLayout = (View) findViewById(R.id.recording_pause_btn_layout);
		recordingStopBtnLayout = (View) findViewById(R.id.recording_stop_btn_layout);

		// 상단 스크린 레이아웃들
		audioRecordScreenLayout = (View) findViewById(R.id.audio_record_screen_layout);	// 녹음 전,녹음 중
		// 상단 재생 관련 스크린 레이아웃
		audioPlayScreenLayout = (View) findViewById(R.id.audio_play_screen_layout);					// 녹음 후
		// 하단 버튼 레이아웃들
		bottomRecordButtonsLayout = (View) findViewById(R.id.audio_record_bottom_record_buttons_layout);	// 녹음 전,녹음 중		
		bottomRecordMenuLayout = (View) findViewById(R.id.audio_record_bottom_menu_layout);					// 녹음 후

//		// 녹음 모드 화면 / 예약 전송 모드 화면
//		record_screen_layout = (View) findViewById(R.id.record_screen_layout);	
//		audio_record_reservation_screen_layout = (View) findViewById(R.id.audio_record_reservation_screen_layout);	

		// 녹음 가능 시간 표시
		usableSecondTxt = (TextView) findViewById(R.id.audio_record_record_usable_second_txt);
		usableSecondTxt.setText(usableSecond+"");	

		// 녹음 마이크 이미지
		recordingViewImage = (ImageView) findViewById(R.id.recording_view_image);

//		// 예약 모드 화면에 있는 입력폼
//		audio_message_reservation_title_txt = (EditText) findViewById(R.id.audio_message_reservation_title_txt);
//		audio_message_reservation_date_btn = (Button) findViewById(R.id.audio_message_reservation_date_btn);
//		audio_message_reservation_time_btn = (Button) findViewById(R.id.audio_message_reservation_time_btn);
//		audio_message_reservation_send_btn = (Button) findViewById(R.id.audio_message_reservation_send_btn);
//
//		audio_message_reservation_date_btn.setOnClickListener(this);
//		audio_message_reservation_time_btn.setOnClickListener(this);
//		audio_message_reservation_send_btn.setOnClickListener(this);

		
		
		
		// 로깅.
		mHandler.sendMessage(mHandler.obtainMessage(THREAD_REGISTER_LOG));
			

		// 녹음기 초기화
		initRecMicToMp3();
		
		mRecMicToMp3.setHandle(new Handler() {
			@Override
			public void handleMessage(Message msg) {
				switch (msg.what) {
				case RecMicToMp3.MSG_REC_STARTED:
					recordWaitStatusLayout.setVisibility(View.GONE);
					recordRecordingStatusLayout.setVisibility(View.VISIBLE);

					// SeekBar 
					mCurRecTimeMs = 0;
					mCurProgressTimeDisplay = 0;
					mProgressHandler.sendEmptyMessageDelayed(0, mProgressCheckStepMs);		// SeekBar의 상태를 mProgressCheckStepMs 후 체크 시작

					// 화면 UI 변경
					recordedTimeTxt.setText("0");		// 녹음 진행 상황 0초 세팅(초기화)
					recordingViewImage.setImageDrawable(getResources().getDrawable(R.drawable.blue_recording_on));	

					recordingStartBtnLayout.setVisibility(View.GONE);
					recordingPauseBtnLayout.setVisibility(View.VISIBLE);
					recordingStopBtnLayout.setVisibility(View.VISIBLE);

					break;
				case RecMicToMp3.MSG_REC_STOPPED:				// 정상 정지
					recordRecordingStatusLayout.setVisibility(View.GONE);
					break;
				case RecMicToMp3.MSG_ERROR_GET_MIN_BUFFERSIZE:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this,
							getString(R.string.record_msg_unsupport_device),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_CREATE_FILE:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_can_not_create_file),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_REC_START:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_can_not_start_record),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_AUDIO_RECORD:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_can_not_record),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_AUDIO_ENCODE:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_fail_to_encoding),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_WRITE_FILE:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_fail_to_writing),
							Toast.LENGTH_LONG).show();
					break;
				case RecMicToMp3.MSG_ERROR_CLOSE_FILE:
					recordWaitStatusLayout.setVisibility(View.VISIBLE);
					recordRecordingStatusLayout.setVisibility(View.GONE);
					Toast.makeText(SendMeAudioRecordActivity.this, 
							getString(R.string.record_msg_fail_to_writing),
							Toast.LENGTH_LONG).show();
					break;
				default:
					break;
				}
			}
		});

		/*
		 * 녹음 진행바를 수동 조작이 불가능하게 한다. 
		 */
		recordSeekBar = (SeekBar) findViewById(R.id.record_seekbar);
		recordSeekBar.setMax(SendMeConstant.RECORDING_TIME);
		recordSeekBar.setOnTouchListener(new OnTouchListener(){
			@Override
			public boolean onTouch(View v, MotionEvent event) {
				return true;
			}
		});

		/*
		 * 재생 진행바
		 */
		mTvPlayMaxPoint = (TextView) findViewById(R.id.tvPlayMaxPoint);		// 시간 표시
		playSeekbar = (SeekBar) findViewById(R.id.play_seekbar);
		playSeekbar.setOnTouchListener(new OnTouchListener() {public boolean onTouch(View v, MotionEvent event) {
			playSeekbarChange(v);
			return false; }
		});

		// 녹음 관련 버튼들
		startButton = (ImageButton) findViewById(R.id.recording_start_btn);
		startButton.setOnClickListener(this);

		stopButton = (ImageButton) findViewById(R.id.recording_stop_btn);		
		stopButton.setOnClickListener(this);

		pauseButton = (ImageButton) findViewById(R.id.recording_pause_btn);
		pauseButton.setOnClickListener(this);

		resumeButton = (ImageButton) findViewById(R.id.recording_resume_btn);
		resumeButton.setOnClickListener(this);

		// 녹음 이후 메뉴 버튼들
		recordingMenuSaveBtn = (ImageButton) findViewById(R.id.recording_menu_save_btn);
		recordingMenuSaveBtn.setOnClickListener(this);

		recordingMenuSendBtn = (ImageButton) findViewById(R.id.recording_menu_send_btn);
		recordingMenuSendBtn.setOnClickListener(this);

		recordingMenuReservationBtn = (ImageButton) findViewById(R.id.recording_menu_reservation_btn);
		recordingMenuReservationBtn.setOnClickListener(this);

		recordingMenuPlayBtn = (ImageButton) findViewById(R.id.recording_menu_play_btn);
		recordingMenuPlayBtn.setOnClickListener(this);

		recordingMenuDeleteBtn = (ImageButton) findViewById(R.id.recording_menu_delete_btn);
		recordingMenuDeleteBtn.setOnClickListener(this);

		// 받는 사람 이름 표시 뷰(재생용)
		audioRecordReceiverNameTxt = (TextView) findViewById(R.id.audio_record_receiver_name_txt);
	}

	/*
	 * 하단 녹음/메뉴 버튼 클릭 리스너
	 */
	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		// 녹음 시작
		case R.id.recording_start_btn:
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_RECORDING_START));
			break;
			// 녹음 완료
		case R.id.recording_stop_btn:				
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_RECORDING_STOP));
			break;
			// 녹음 중지
		case R.id.recording_pause_btn:
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_RECORDING_PAUSE));
			break;
			// 녹음 재개
		case R.id.recording_resume_btn:
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_RECORDING_RESUME));
			break;

			// 임시 저장 확인
		case R.id.recording_menu_save_btn:
			mHandler.sendMessage(mHandler.obtainMessage(CONFIRM_SAVE_TEMP_AUDIO_FILE));
			break;
			
			// 보내기
		case R.id.recording_menu_send_btn:
//			threadRegisterVoice();		// 바로 전송
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_CONFIRM_SEND_AUDIO));		// 확인 후 전송	
			break;
			
			// 예약 전송 화면으로
		case R.id.recording_menu_reservation_btn:
			// --> 별도 액티비티를 호출하도록 변경
			Intent intent = new Intent(this, SendMeAudioSendReservationActivity.class);
			intent.putExtra("sender", sender);
			intent.putExtra("filePath", tempMP3FileName());
			intent.putExtra("fileName", fileName);
			intent.putExtra("receiverList", receiverList);
			intent.putExtra("receiverNameList", receiverNameList);
			startActivityForResult(intent, THREAD_CHANGE_TO_RESERVATION_SCREEN);
			break;
			
			// 재생
		case R.id.recording_menu_play_btn:
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_PLAYING_RECORD));
			break;

			// 삭제 후 닫기
		case R.id.recording_menu_delete_btn:
			resultIntent.putExtras(extraBundle);
			setResult(RESULT_OK, resultIntent);
			deleteTempFileAndFinishActivity();
			break;
		}

	}
	
	
	// 확인창.
	/**
	 * 음성 메시지 전송전 확인 창을 띄운다
	 */
	private Runnable confirmSendAudio = new Runnable() {
		@Override
		public void run() {
			
			String dialogReceiver = "";
			if(receiverNameList.length==1) {
					dialogReceiver = receiverNameList[0]+" 님";	// receiverList --> receiverNameList
			} else {
				dialogReceiver = "그룹";
			}
			
			new AlertDialog.Builder(SendMeAudioRecordActivity.this)
			.setTitle("전송 확인")
			.setMessage(dialogReceiver + "에게 음성 메시지를 전송하시겠습니까?")
			.setNegativeButton("취소", new DialogInterface.OnClickListener() {

				@Override
				public void onClick(DialogInterface dialog, int which) {

				}
			})
			.setPositiveButton("확인", new DialogInterface.OnClickListener() {
				
				@Override
				public void onClick(DialogInterface dialog, int which) {
					threadRegisterVoice();
				}
			}).show();
			
		}
	};
	/**
	 * 음성 메시지 임시 저장전 확인 창을 띄운다
	 */
	private Runnable confirmSaveAudioToTemp = new Runnable() {
		@Override
		public void run() {
			
			new AlertDialog.Builder(SendMeAudioRecordActivity.this)
			.setTitle("임시 저장 확인")
			.setMessage("음성 메시지를 임시 보관함에 저장하시겠습니까?")
			.setNegativeButton("취소", new DialogInterface.OnClickListener() {

				@Override
				public void onClick(DialogInterface dialog, int which) {

				}
			})
			.setPositiveButton("확인", new DialogInterface.OnClickListener() {
				
				@Override
				public void onClick(DialogInterface dialog, int which) {
					saveTempAudioFile();	
				}
			}).show();
			
		}
	};
	
	// 토스트
	/**
	 * 음성 메시지 전송에 성공했다는 toast 를 띄운다.
	 */
	public void showToastAudioSendSuccess() {					
		CharSequence text = "메시지가 전송 되었습니다";
		Toast toast = Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER_VERTICAL|Gravity.CENTER_HORIZONTAL, 0, 0);
		toast.show();
	}
	/**
	 * 음성 메시지 전송에 실패했다는 toast 를 띄운다.
	 */
	public void showToastAudioSendFail() {
		CharSequence text = "메시지 전송에 실패하였습니다";
		Toast toast = Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER_VERTICAL|Gravity.CENTER_HORIZONTAL, 0, 0);
		toast.show();
	}
	/**
	 * 음성 메시지 임시 저장에 성공했다는 toast 를 띄운다.
	 */
	public void showToastAudioSaveToTempSuccess() {
		CharSequence text = "임시 보관함에 저장되었습니다.";
		Toast toast = Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER_VERTICAL|Gravity.CENTER_HORIZONTAL, 0, 0);
		toast.show();
	}
	/**
	 * 음성 메시지 임시 저장에 실패했다는 toast 를 띄운다.
	 */
	public void showToastAudioSaveToTempFail() {
		CharSequence text = "임시 저장에 실패하였습니다.";
		Toast toast = Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER_VERTICAL|Gravity.CENTER_HORIZONTAL, 0, 0);
		toast.show();
	}

	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 녹음 관련 기능들

	/**
	 * 필요한 핸들러를 등록해서 사용한다.
	 */
	private Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
			switch(msg.what) {
			
			// 로그를 남긴다
			case THREAD_REGISTER_LOG : 
				threadRegisterLog();
				break;
			// 녹음을 시작한다
			case THREAD_RECORDING_START : 
				runOnUiThread(startRecording);
				break;
				// 녹음을 완료한다
			case THREAD_RECORDING_STOP : 
				runOnUiThread(stopRecording);
				break;
				// 녹음을 중지한다
			case THREAD_RECORDING_PAUSE : 
				runOnUiThread(pauseRecording);
				break;
				// 녹음을 재개한다
			case THREAD_RECORDING_RESUME : 
				runOnUiThread(resumeRecording);
				break;
				// 녹음한 음성을 재생한다
			case THREAD_PLAYING_RECORD : 
				runOnUiThread(playRecording);
				break;
				
				
				// 음성 메시지 전송전 확인 창을 띄운다		
			case THREAD_CONFIRM_SEND_AUDIO : 
				runOnUiThread(confirmSendAudio);				
				break;
				
				// (서버 통신) 프로그레스 바를 출력 한다.
			case THREAD_PROGRESS_BAR_VISIBLE : 
					dialog.show();
				break;
				// (서버 통신) 프로그레스 바를 감춘다.
			case THREAD_PROGRESS_BAR_INVISIBLE : 
				dialog.hide();
				break;
				// (서버 통신) 전송 성공 토스트를 띄운다	
			case THREAD_TOAST_SEND_SUCCESS : 
				showToastAudioSendSuccess();		
				break;	
				// (서버 통신) 전송 실패 토스트를 띄운다
			case THREAD_TOAST_SEND_FAIL :
				showToastAudioSendFail();
				break;	

				// 음성 메시지를 임시 저장 확인받는다
			case CONFIRM_SAVE_TEMP_AUDIO_FILE :
				runOnUiThread(confirmSaveAudioToTemp);		
				break;		
				// 음성 메시지를 임시 저장한다
			case THREAD_SAVE_TEMP_AUDIO_FILE :
				saveTempAudioFile();
				break;		
				// 음성 메시지를 임시 저장 성공 토스트를 띄운다
			case THREAD_TOAST_TEMP_SAVE_SUCCESS :
				showToastAudioSaveToTempSuccess();
				break;	
				// 음성 메시지를 임시 저장 실패 토스트를 띄운다
			case THREAD_TOAST_TEMP_SAVE_FAIL :
				showToastAudioSaveToTempFail();
				break;	
				
			}
		}
	};
	/**
	 * 녹음을 시작한다
	 */
	private Runnable startRecording = new Runnable() {
		@Override
		public void run() {
			// 녹음 시작
			mRecMicToMp3.start();		// 나머지 변경사항은 녹음이 성공적으로 시작되면 호출되도록 함
		}
	};
	/**
	 * 녹음을 완료한다
	 */
	private Runnable stopRecording = new Runnable() {
		@Override
		public void run() {

			// SeekBar
			mCurRecTimeMs = -999;	
			mProgressHandler.sendEmptyMessageDelayed(0, 0);				    // SeekBar의 상태를 즉시 체크 

			// 녹음 완료
			mRecMicToMp3.stop();

			// 화면 변경 - 마이크 이미지 변경 / 하단 버튼 레이아웃 변경 / 상단 상태 표시 문구 변경
			recordingViewImage.setImageDrawable(getResources().getDrawable(R.drawable.blue_recording_off));	
			bottomRecordButtonsLayout.setVisibility(View.GONE);		
			bottomRecordMenuLayout.setVisibility(View.VISIBLE);		
			recordWaitStatusLayout.setVisibility(View.GONE);
			recordRecordingStatusLayout.setVisibility(View.GONE);
			recordRecordeResultLayout.setVisibility(View.VISIBLE);
		}
	};
	/**
	 * 녹음을 중지한다
	 */
	private Runnable pauseRecording = new Runnable() {
		@Override
		public void run() {
			mRecMicToMp3.pause();
			recordingViewImage.setImageDrawable(getResources().getDrawable(R.drawable.blue_recording_off));	
			recordingPauseBtnLayout.setVisibility(View.GONE);
			recordingResumeBtnLayout.setVisibility(View.VISIBLE);
		}
	};
	/**
	 * 녹음을 재개한다
	 */
	private Runnable resumeRecording = new Runnable() {
		@Override
		public void run() {
			mRecMicToMp3.resume();
			recordingViewImage.setImageDrawable(getResources().getDrawable(R.drawable.blue_recording_on));	
			recordingResumeBtnLayout.setVisibility(View.GONE);
			recordingPauseBtnLayout.setVisibility(View.VISIBLE);
		}
	};
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 재생 관련 기능들

	/**
	 * 녹음한 음성을 재생한다
	 */
	private Runnable playRecording = new Runnable() {
		@Override
		public void run() {
			// 화면 UI 변경
			if(receiverNameList.length==1){
				audioRecordReceiverNameTxt.setText(receiverNameList[0]);	// receiverList --> receiverNameList
			}else{
				audioRecordReceiverNameTxt.setText("그룹 전송");
			}
			audioRecordScreenLayout.setVisibility(View.GONE);
			audioPlayScreenLayout.setVisibility(View.VISIBLE);
			// 음성을 재생한다
			initMediaPlayer();
			startPlay();
		}
	};

	/*
	 * 진행바를 터치하여 미디어 플레이어를 컨트롤할수 있도록한다
	 */
	private void playSeekbarChange(View v){
		if(mPlayer.isPlaying()){
			SeekBar sb = (SeekBar)v;
			mPlayer.seekTo(sb.getProgress());
		}
	}

	/*
	 * 미디어 플레이어 초기화
	 */
	private void initMediaPlayer()
	{
		// 미디어 플레이어 생성
		if (mPlayer == null)
			mPlayer = new MediaPlayer();
		else{
			mPlayer.reset();
		}
		mPlayer.setOnCompletionListener(this);
		String fullFilePath = tempMP3FileName();

		try
		{
			mPlayer.setDataSource(fullFilePath);
			mPlayer.prepare();   
			int point = mPlayer.getDuration();
			playSeekbar.setMax(point);

			int maxMinPoint = point / 1000 / 60;
			int maxSecPoint = (point / 1000) % 60;
			String maxMinPointStr = "";
			String maxSecPointStr = "";

			if (maxMinPoint < 10)
				maxMinPointStr = "0" + maxMinPoint + ":";
			else
				maxMinPointStr = maxMinPoint + ":";

			if (maxSecPoint < 10)
				maxSecPointStr = "0" + maxSecPoint;
			else
				maxSecPointStr = String.valueOf(maxSecPoint);

			mTvPlayMaxPoint.setText(maxMinPointStr + maxSecPointStr);		// 시간 값?

			playSeekbar.setProgress(0);	// init
		}
		catch(Exception e)
		{
			Log.d("ProgressRecorder", "media player Prepare Error : " + e);
		}
	}

	// 재생 시작
	private void startPlay()
	{
		Log.d("ProgressRecorder", "startPlay().....");
		try
		{
			mPlayer.start();

			// SeekBar의 상태를 mProgressCheckStepMs 마다 체크      
			mProgressHandler2.sendEmptyMessageDelayed(0, mProgressCheckStepMs);
		}
		catch (Exception e)
		{
			e.printStackTrace();
			Toast.makeText(this, "error : " + e.getMessage(), 0).show();
		}
	}

	@Override
	public void onCompletion(MediaPlayer mp)
	{
		// 재생이 끝났으므로 진행바를 가장 끝으로 위치시킨다
		playSeekbar.setProgress(mPlayer.getDuration());
		// 재생이 종료되면 즉시 SeekBar 메세지 핸들러를 호출한다. 
		mProgressHandler2.sendEmptyMessageDelayed(0, 0);
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 예약 관련 기능들
	
	@Override
	public void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		Bundle extraBundle2;
		if( requestCode == THREAD_CHANGE_TO_RESERVATION_SCREEN ) {
			if(resultCode == Activity.RESULT_OK){		// 정상 반환시.
				Log.d(TAG,"RESULT_OK");
				extraBundle2 = data.getExtras();		// 번들을 반환했으니까 번들을 불러오면 세팅된 값을 가지고 있음.

//				String key1 = extraBundle.getString("key1");	
//				Log.d(TAG,"key1:"+key1);
				
				// 예약 메시지 목록 띄워주기.
				Intent intent = new Intent(this, SendMeReservationMessageListActivity.class);
				startActivity(intent);
				
				// 성공시 지우고 종료. 예약 메시지 리스트로 이동하니까 상위까지 종료.
//				// 키,벨류를 넣는다
//				extraBundle.putString("key1",  "val1");	
				resultIntent.putExtras(extraBundle);
				setResult(RESULT_MAIN_MENU_CALLED, resultIntent);
				deleteTempFileAndFinishActivity();
				
				
			}else if(resultCode == Activity.RESULT_CANCELED){
				Log.d(TAG,"RESULT_CANCELED");
			}else if(resultCode == RESULT_MAIN_MENU_CALLED){
				Log.d(TAG,"RESULT_MAIN_MENU_CALLED");
				
				// 화면을 닫는다.
				setResult(RESULT_MAIN_MENU_CALLED, resultIntent);
				deleteTempFileAndFinishActivity();
				
			}
		}
	}
	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 임시 저장 관련 기능들
	
	/**
	 * 음성 메시지를 임시 저장한다
	 * @param savedInstanceState
	 */
	public void saveTempAudioFile(){
		
		String filePath = tempMP3FileName();
		
		SendMeCommon sendMeCommon = new SendMeCommon();
		String receiverListToString = sendMeCommon.convertArrayToString(receiverList);
		String receiverNameListToString = sendMeCommon.convertArrayToString(receiverNameList);  
		
		SendMeVoice sendMeVoice = new SendMeVoice();
		sendMeVoice.setSender(sender);
		sendMeVoice.setReceiver(receiverListToString);					// ### "/" 로 구분하여 한개 String 으로 변환
		sendMeVoice.setReceiverName(receiverNameListToString);					// ### "/" 로 구분하여 한개 String 으로 변환
		sendMeVoice.setRegisterDate(sendMeCommon.getCurrentDate());		
		sendMeVoice.setModifyDate(sendMeCommon.getCurrentDate());
		sendMeVoice.setFileName(fileName);
		sendMeVoice.setFilePath(filePath);

		SendMeDBManagerAudioRecord sendMeDBManagerAudioRecord = new SendMeDBManagerAudioRecord(this);
		if(sendMeDBManagerAudioRecord.insertTempAudioData(sendMeVoice)) {
			// 성공 알림 토스트 후 종료 (파일 삭제 없음)
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_TOAST_TEMP_SAVE_SUCCESS));

			// 임시 저장 성공했으니 재생화면 이전 리스트로
			resultIntent.putExtras(extraBundle);
			setResult(RESULT_OK, resultIntent);
			
			// 화면을 닫는다.
			sendMeActivityManager.removeActivity(SendMeAudioRecordActivity.this);
			finish();
			
		} else {
			// 실패 알림 토스트
			mHandler.sendMessage(mHandler.obtainMessage(THREAD_TOAST_TEMP_SAVE_FAIL));
		}
	}
	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
	// 서버 통신

	/**
	 * 음성 메시지를 등록한다
	 *  일반 리스트를 서버로 전송할때는 서버에서 RequestBody 로 받아서 json을 자동으로 object 변환시켜주므로
	 *    jsonArray 에 jsonObject 를 담을때 toString() 처리하여 담아서 보내야 하지만 
	 *  multipart로 파일을 전송하는 경우에는 서버에서 RequestParam 으로 받는데 이때에는 json을 자동으로 object 변환하지 않기 때문에
	 *   jsonArray 에 jsonObject 를 담을때 jsonObject 그대로 넣어야 서버에서 받을때 넣은 json 형태 그대로 꺼내어진다. 
	 */
	public void threadRegisterVoice() {

		// 프로그레스 바를 출력 한다.
		mHandler.sendMessage(mHandler.obtainMessage(THREAD_PROGRESS_BAR_VISIBLE));

		Thread thread = new Thread(new Runnable() {

			public void run() {
				// TODO Auto-generated method stub
				
				// 받는 사람 리스트를 string 데이터로 변환
				JSONObject jsonObject = null;
				JSONArray jsonArray = new JSONArray();
				String receiverListStr = "";
				try{
					for(int i=0; i<receiverList.length; i++){
						// 방법 1
						jsonObject = new JSONObject();
						jsonObject.put("phoneNumber", receiverList[i]);
//						jsonArray.put(jsonObject.toString());			// 서버로 전송 실패하게 됨
						jsonArray.put(jsonObject);						
					}
					receiverListStr = jsonArray.toString();
					Log.d(TAG,"receiverListStr:"+receiverListStr);		
				}catch(Exception e){
					e.printStackTrace();
				}
				
				SendMeCommon sendMeCommon = new SendMeCommon();

				SendMeVoice sendMeVoice = new SendMeVoice();
				sendMeVoice.setIdSendMeVoice("");			// 테이블 아이디.(PK)	

				sendMeVoice.setSender(sender);		//	생성자. 보내는 멤버 휴대 전화 번호.	
				sendMeVoice.setReceiver(receiverListStr);		// 받는 멤버 휴대 전화 번호.		 

				sendMeVoice.setActivateYn("Y");				// 활성화 여부.	
				sendMeVoice.setModifyDate(sendMeCommon.getCurrentDate());				// 수정 일자.	
				sendMeVoice.setRegisterDate(sendMeCommon.getCurrentDate());				// 등록 일자.	

				sendMeVoice.setAvailableDay(SendMeConstant.AVAILABLE_DAY);			// 사용 가능 기간 일수. 기본값은 7	
				sendMeVoice.setReadYn("N");					// 읽음 여부. 기본값은 N			

				// 일반 전송
				sendMeVoice.setDeliveryYn("Y");				// 예약 발송일 경우  N				
				sendMeVoice.setReservationDate("");			// 예약 발송일 경우 날짜				
				sendMeVoice.setReservationTime("");			// 예약 발송일 경우 시각

				sendMeVoice.setFileName(fileName);				// 파일 명.	

				// 음성 파일.
				String fileChk = tempMP3FileName();

				File file = new File(fileChk);
				if(file.exists()){
					try {
						sendMeVoice.setFile(file);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				//				sendMeVoice.setFileContentType("audio/mpeg");			// FileContentType for mp3

				SendMeAudioMessageRest sendMeAudioMessageRest = new SendMeAudioMessageRest();
				SendMeVoice result = new SendMeVoice();
//				result = sendMeAudioMessageRest.registerVoice(sendMeVoice);		// 원본 - 가끔 성공했는데 실패 처리가 되는 경우가 있어서 아래의 것을 사용
				result = sendMeAudioMessageRest.registerVoice2(sendMeVoice);	// 테스트용

				// 프로그레스 바를 감춘다.
				mHandler.sendMessage(mHandler.obtainMessage(THREAD_PROGRESS_BAR_INVISIBLE));

				// 인증번호 요청에 성공하면 toast 를 띄워서 알려준다. 
				if(("SUCCESS").equals(result.getResult())) {

					// 성공 알림 토스트
					// 일반 보내기
					mHandler.sendMessage(mHandler.obtainMessage(THREAD_TOAST_SEND_SUCCESS));
					// 종료 프로세스
					resultIntent.putExtras(extraBundle);
					setResult(RESULT_OK, resultIntent);
					deleteTempFileAndFinishActivity();
				}else{
					// 실패 알림 토스트
					mHandler.sendMessage(mHandler.obtainMessage(THREAD_TOAST_SEND_FAIL));
				}
			}
		});
		thread.start();
	}
	
	/**
	 * 로그를 남긴다	 
	 */
	public void threadRegisterLog() {
		Thread thread = new Thread(new Runnable() {
			public void run() {
				
				SendMeCommon sendMeCommon = new SendMeCommon();
				String nowTime = sendMeCommon.getCurrentDate();
				
				SendMeLog sendMeLog = new SendMeLog();
				sendMeLog.setPhoneNumber(sender);
				sendMeLog.setViewName(TAG);
				sendMeLog.setRegisterDate(nowTime);
				
				SendMeLogRest sendMeLogRest = new SendMeLogRest();
				
				sendMeLogRest.registerLog(sendMeLog);
			}
		});
		thread.start();
	}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/**
	 * SharedPreference 정보를 확인 한다.
	 */
	public void confirmNotification() {
		SharedPreferences mSharedPreference = getSharedPreferences(SendMeConstant.SENDME_PREFERENCE, Activity.MODE_PRIVATE);

		sender = mSharedPreference.getString("phone_number", "");
		Log.i(TAG, "sender : " + sender);
	}

	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
	// 액티비티 종료 관련 기능들

	/**
	 * 뒤로 가기 버튼을 정의 한다.
	 * 화면을 종료 한다.
	 */
	@Override
	public void onBackPressed() {
		extraBundle.putBoolean("finishYn", false);	
		resultIntent.putExtras(extraBundle);
		setResult(RESULT_CANCELED, resultIntent);
		deleteTempFileAndFinishActivity();
	}

	/**
	 * 액티비티를 종료한다
	 *  디바이스의 뒤로가기 버튼으로 인한 종료 / 화면에서의 버튼 조작에 의한 액션 처리 이후 닫을때 호출된다
	 */
	public void deleteTempFileAndFinishActivity(){
		
		// 임시 파일이 있다면 지운다.
		checkAndDeleteTempFile();
		
		// 화면을 닫는다.
		sendMeActivityManager.removeActivity(SendMeAudioRecordActivity.this);
		finish();
	}

	/**
	 * 임시 파일이 있는지 체크하고 있다면 지운다.
	 */
	public void checkAndDeleteTempFile(){
		
		mRecMicToMp3.stop(); 
		if(mPlayer!=null){
			mPlayer.reset();
			//			mPlayer.release();	
			mPlayer = null;
		}
		
		String fileChk = tempMP3FileName();
		File file = new File(fileChk);
		if(file.exists()){
			file.delete();
		}
	}
	
	@Override
	public void onResume(){
		super.onResume();
		dialog = ProgressDialog.show(SendMeAudioRecordActivity.this, "", "Send..", true);	// 제목, 내용
		dialog.hide();
	}
	@Override
	public void onStop(){
		super.onStop();
		dialog.dismiss();
	}
	
	
}
